home *** CD-ROM | disk | FTP | other *** search
/ Night Owl 6 / Night Owl's Shareware - PDSI-006 - Night Owl Corp (1990).iso / 039a / mawk.zip / JMP.C < prev    next >
C/C++ Source or Header  |  1991-04-07  |  6KB  |  218 lines
  1.  
  2. /********************************************
  3. jmp.c
  4. copyright 1991, Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the Awk programming language as defined in
  8. Aho, Kernighan and Weinberger, The AWK Programming Language,
  9. Addison-Wesley, 1988.
  10.  
  11. See the accompaning file, LIMITATIONS, for restrictions
  12. regarding modification and redistribution of this
  13. program in source or binary form.
  14. ********************************************/
  15.  
  16. /* $Log:    jmp.c,v $
  17.  * Revision 2.1  91/04/08  08:23:19  brennan
  18.  * VERSION 0.97
  19.  * 
  20. */
  21.  
  22. /* this module deals with back patching jumps, breaks and continues,
  23.    and with save and restoring code when we move code.
  24.    There are three stacks.  If we encounter a compile error, the
  25.    stacks are frozen, i.e., we do not attempt error recovery
  26.    on the stacks
  27. */
  28.  
  29.  
  30. #include "mawk.h"
  31. #include "jmp.h"
  32. #include "code.h"
  33. #include "sizes.h"
  34. #include "init.h"
  35. #include "memory.h"
  36.  
  37. extern unsigned compile_error_count ;
  38. #define error_state  (compile_error_count>0)
  39.  
  40.  
  41. /* a stack to hold jumps that need to be patched */
  42.  
  43. #define JMP_STK_SZ  (2*MAX_LOOP_DEPTH)
  44.  
  45. static INST **jmp_stack ; 
  46. static INST **jmp_sp  ;
  47.  
  48. /*-------------------------------------*/
  49. /* a stack to hold break or continue that need to be
  50.    patched (which is all of them) */
  51.  
  52. #define  BC_SZ    MAX_LOOP_DEPTH
  53.  
  54. /* the stack holds a linked list of these */
  55.  
  56. struct BC_node { /* struct for the break/continue list */
  57. char type ;   /*  'B' or 'C' */
  58. INST *jmp ;   /*  the jump to patch */
  59. struct BC_node *link ;
  60. } ;
  61.  
  62. static   struct BC_node  **BC_stack ;
  63. static   struct BC_node  **BC_sp ;
  64.  
  65. /*---------------------------------------*/
  66. /* a stack to hold some pieces of code while 
  67.    reorganizing loops */
  68.  
  69. #define  LOOP_CODE_SZ    (2*MAX_LOOP_DEPTH)
  70.  
  71. static struct loop_code {
  72. INST *code ;
  73. unsigned short len ;
  74. }  *loop_code_stack , *lc_sp ;
  75.  
  76. /*--------------------------------------*/
  77. void jmp_stacks_init()
  78. { jmp_stack = (INST **)  zmalloc(JMP_STK_SZ*sizeof(INST*)) ;
  79.   jmp_sp = jmp_stack-1 ;
  80.  
  81.   BC_stack = (struct BC_node **) 
  82.               zmalloc(BC_SZ*sizeof(struct BC_node*)) ;
  83.   BC_sp =  BC_stack-1 ;
  84.  
  85.   loop_code_stack = (struct loop_code *)
  86.                     zmalloc(LOOP_CODE_SZ*sizeof(struct loop_code)) ;
  87.   lc_sp = loop_code_stack - 1 ;
  88. }
  89.  
  90. void jmp_stacks_cleanup()
  91. { zfree(jmp_stack, JMP_STK_SZ*sizeof(INST*)) ;
  92.   zfree(BC_stack, BC_SZ*sizeof(struct BC_node*)) ;
  93.   zfree(loop_code_stack, LOOP_CODE_SZ*sizeof(struct loop_code)) ;
  94. }
  95. /*--------------------------------------*/
  96. /* operations on the jmp_stack */
  97.  
  98. void code_jmp( jtype, target)
  99.   int jtype ; INST *target ;
  100. { 
  101.   if (error_state)  return ;
  102.  
  103.   /* check if a constant expression will be at top of stack,
  104.      if so replace conditional jump with jump */
  105.  
  106.   if ( code_ptr[-2].op == _PUSHC && jtype != _JMP )
  107.   { int t = test( (CELL *) code_ptr[-1].ptr ) ;
  108.     if ( jtype == _JZ && ! t ||
  109.          jtype == _JNZ && t )
  110.     { code_ptr -= 2 ; jtype = _JMP ; }
  111.   }
  112.    
  113.   if ( ! target ) /* jump will have to be patched later ,
  114.                      put it on the jmp_stack */
  115.   { if ( ++jmp_sp == jmp_stack + JMP_STK_SZ )
  116.           overflow("jmp stack" , JMP_STK_SZ ) ; 
  117.     *jmp_sp = code_ptr ;
  118.     code2(jtype, 0) ;
  119.   }
  120.   else
  121.   { INST *source = code_ptr ;
  122.   
  123.     code_ptr++->op = jtype ;
  124.     code_ptr++->op = target - source ; 
  125.   }
  126. }
  127.  
  128. void patch_jmp(target)  /* patch a jump on the jmp_stack */
  129.   INST *target ;
  130. { register INST *source ;
  131.  
  132.   if ( ! error_state )
  133.   {
  134.     if ( jmp_sp <= jmp_stack-1 ) bozo("jmp stack underflow") ;
  135.     source = *jmp_sp-- ;
  136.     source[1].op = target - source ;
  137.   }
  138. }
  139.  
  140.  
  141. /*---------------------------*/
  142.  
  143. /* a stack of linked lists of BC_nodes for patching 
  144.    break and continue statements.  */
  145.  
  146.  
  147. void BC_new()  /* push an empty list on the stack */
  148. { 
  149.   if ( ! error_state )
  150.   { if ( ++BC_sp == BC_stack + BC_SZ ) overflow("BC stack", BC_SZ) ;
  151.     * BC_sp = (struct BC_node *) 0 ;
  152.   }
  153. }
  154.  
  155. void BC_insert(type, address)
  156.   int type ; INST *address ;
  157. { register struct BC_node *p ; 
  158.  
  159.   if ( error_state )  return ;
  160.   if ( BC_sp <= BC_stack - 1 )
  161.   {  compile_error(  type == 'B' ?
  162.         "break statement outside of loop" :
  163.         "continue statement outside of loop" ) ; 
  164.      return ;
  165.   }
  166.   
  167.   p = (struct BC_node *) zmalloc( sizeof(struct BC_node) ) ;
  168.   p->type = type ; p->jmp = address ;
  169.   p->link = *BC_sp ; *BC_sp = p ;
  170. }
  171.  
  172. void BC_clear(B_address, C_address)  
  173. /* patch all break and continues on list */
  174. INST *B_address, *C_address ;
  175. { register struct BC_node *p , *q ;
  176.  
  177.   if (error_state) return ;
  178.   if ( BC_sp <= BC_stack-1) bozo("underflow on BC stack") ;
  179.   p = *BC_sp-- ;
  180.   while ( p )
  181.   { p->jmp[1].op = (p->type=='B' ? B_address : C_address) - p->jmp ;
  182.     q = p ; p = p->link ; zfree(q, sizeof(struct BC_node)) ;
  183.   }
  184. }
  185.  
  186. /*---------------------------------------------*/
  187. /*  save and restore some code for reorganizing
  188.     loops on a stack */
  189.  
  190.  
  191. void code_push( p, len)
  192.   INST *p ; unsigned len ;
  193. { 
  194.   if (error_state) return ;
  195.   if ( ++lc_sp == loop_code_stack + LOOP_CODE_SZ )
  196.         overflow("loop_code_stack" , LOOP_CODE_SZ) ;
  197.  
  198.   if ( len )
  199.   { lc_sp->code = (INST *) zmalloc(sizeof(INST) * len) ;
  200.     (void) memcpy(lc_sp->code, p, sizeof(INST) * len) ; }
  201.   else  lc_sp->code = (INST *) 0 ;
  202.   lc_sp->len = (unsigned short) len ;
  203. }
  204.  
  205. /* copy the code at the top of the loop code stack to target.
  206.    return the number of bytes moved */
  207.  
  208. unsigned code_pop(target) 
  209.   INST *target ;
  210. { 
  211.   if (error_state)  return 0 ;
  212.   if ( lc_sp <= loop_code_stack-1 )  bozo("loop code stack underflow") ;
  213.   if ( lc_sp->len )
  214.   { (void) memcpy(target, lc_sp->code, lc_sp->len * sizeof(INST)) ;
  215.     zfree(lc_sp->code, sizeof(INST)*lc_sp->len) ; }
  216.   return lc_sp-- -> len ;
  217. }
  218.